ஜாவாஸ்கிரிப்ட் சூழலைத் திறத்தல்: டைப்ஸ்கிரிப்ட் அறிவிப்பு கோப்புகளின் ஒரு ஆழமான ஆய்வு

டைப்ஸ்கிரிப்ட், டைனமிக் ஜாவாஸ்கிரிப்ட் உலகில் ஸ்டாட்டிக் டைப்பிங்கை கொண்டு வருவதன் மூலம் நவீன வலை வளர்ச்சியை புரட்சிகரமாக மாற்றியுள்ளது. இந்த வகை பாதுகாப்பு நம்பமுடியாத நன்மைகளை வழங்குகிறது: கம்பைல் நேரத்தில் பிழைகளை கண்டறிதல், சக்திவாய்ந்த எடிட்டர் தானியங்கு நிறைவை இயக்குதல் மற்றும் பெரிய குறியீட்டு தளங்களை கணிசமாக பராமரிக்கக்கூடியதாக மாற்றுதல். இருப்பினும், தற்போதுள்ள ஜாவாஸ்கிரிப்ட் நூலகங்களின் பரந்த சூழலைப் பயன்படுத்த நாம் விரும்பும்போது ஒரு பெரிய சவால் எழுகிறது - அவற்றில் பெரும்பாலானவை டைப்ஸ்கிரிப்டில் எழுதப்படவில்லை. எங்கள் கண்டிப்பாக-வகைப்படுத்தப்பட்ட டைப்ஸ்கிரிப்ட் குறியீடு, வகைப்படுத்தப்படாத ஜாவாஸ்கிரிப்ட் நூலகத்திலிருந்து வடிவங்கள், செயல்பாடுகள் மற்றும் மாறிகளை எவ்வாறு புரிந்துகொள்ள முடியும்?

இதற்கான பதில் டைப்ஸ்கிரிப்ட் அறிவிப்பு கோப்புகளில் உள்ளது. இந்தக் கோப்புகள், அவற்றின் .d.ts நீட்டிப்பால் அடையாளம் காணப்படுகின்றன, டைப்ஸ்கிரிப்ட் மற்றும் ஜாவாஸ்கிரிப்ட் உலகங்களுக்கு இடையிலான அத்தியாவசிய பாலமாகும். அவை ஒரு ப்ளூபிரிண்ட் அல்லது API ஒப்பந்தமாக செயல்படுகின்றன, உண்மையான செயலாக்கத்தைக் கொண்டிருக்காமல் மூன்றாம் தரப்பு நூலகத்தின் வகைகளை விவரிக்கின்றன. இந்த விரிவான வழிகாட்டியில், உங்கள் டைப்ஸ்கிரிப்ட் திட்டங்களில் எந்தவொரு ஜாவாஸ்கிரிப்ட் நூலகத்திற்கும் வகை வரையறைகளை நம்பிக்கையுடன் நிர்வகிக்க நீங்கள் தெரிந்து கொள்ள வேண்டிய அனைத்தையும் நாங்கள் ஆராய்வோம்.

டைப்ஸ்கிரிப்ட் அறிவிப்பு கோப்புகள் என்றால் என்ன?

வேறு மொழியில் பேசும் ஒரு ஒப்பந்தக்காரரை நீங்கள் பணியமர்த்தியதாக கற்பனை செய்து பாருங்கள். அவர்களுடன் திறம்பட வேலை செய்ய, உங்களுக்கு ஒரு மொழிபெயர்ப்பாளர் அல்லது நீங்கள் இருவரும் புரிந்துகொள்ளக்கூடிய மொழியில் விரிவான அறிவுறுத்தல்கள் தேவைப்படும். ஒரு அறிவிப்பு கோப்பு டைப்ஸ்கிரிப்ட் கம்பைலருக்கு (ஒப்பந்தக்காரர்) இந்த துல்லியமான நோக்கத்தை நிறைவேற்றுகிறது.

ஒரு .d.ts கோப்பு வகை தகவலை மட்டுமே கொண்டுள்ளது. இது உள்ளடக்கியது:

• செயல்பாடுகள் மற்றும் முறைகளுக்கான கையொப்பங்கள் (அளவுரு வகைகள், திரும்பும் வகைகள்).
• மாறிகள் மற்றும் அவற்றின் வகைகளுக்கான வரையறைகள்.
• சிக்கலான பொருட்களுக்கான இடைமுகங்கள் மற்றும் வகை மாற்றுப்பெயர்கள்.
• அவற்றின் பண்புகள் மற்றும் முறைகள் உட்பட வகுப்பு வரையறைகள்.
• பெயர்வெளி மற்றும் தொகுப்பு கட்டமைப்புகள்.

முக்கியமாக, இந்தக் கோப்புகளில் செயல்படுத்தக்கூடிய குறியீடு இல்லை. அவை ஸ்டாட்டிக் பகுப்பாய்விற்காக மட்டுமே. நீங்கள் Lodash போன்ற ஒரு ஜாவாஸ்கிரிப்ட் நூலகத்தை உங்கள் டைப்ஸ்கிரிப்ட் திட்டத்தில் இறக்குமதி செய்யும்போது, கம்பைலர் அதனுடன் தொடர்புடைய அறிவிப்பு கோப்பைத் தேடும். ஒன்றைக் கண்டால், அது உங்கள் குறியீட்டைச் சரிபார்க்கலாம், புத்திசாலித்தனமான தானியங்கு நிறைவை வழங்கலாம் மற்றும் நீங்கள் நூலகத்தை சரியாகப் பயன்படுத்துகிறீர்கள் என்பதை உறுதிசெய்யலாம். ஒன்றைக் காணவில்லை என்றால், அது 'lodash' க்கான அறிவிப்பு கோப்பைக் கண்டறிய முடியவில்லை போன்ற ஒரு பிழையை எழுப்பும்.

தொழில்முறை வளர்ச்சிக்கு அறிவிப்பு கோப்புகள் ஏன் தவிர்க்க முடியாதவை

டைப்ஸ்கிரிப்ட் திட்டத்தில் சரியான வகை வரையறைகள் இல்லாமல் ஜாவாஸ்கிரிப்ட் நூலகங்களைப் பயன்படுத்துவது, டைப்ஸ்கிரிப்டைப் பயன்படுத்துவதற்கான காரணத்தையே குறைமதிப்பிற்கு உட்படுத்துகிறது. பிரபலமான பயன்பாட்டு நூலகமான Lodash ஐப் பயன்படுத்தி ஒரு எளிய சூழ்நிலையை பரிசீலிப்போம்.

வகை வரையறைகள் இல்லாத உலகம்

அறிவிப்பு கோப்பு இல்லாமல், டைப்ஸ்கிரிப்டுக்கு lodash என்றால் என்ன அல்லது அதில் என்ன உள்ளது என்பது தெரியாது. குறியீட்டை கம்பைல் செய்ய, நீங்கள் இது போன்ற ஒரு விரைவான தீர்வைப் பயன்படுத்த தூண்டப்படலாம்:

const _: any = require('lodash'); const users = [{ 'user': 'barney' }, { 'user': 'fred' }]; // தானியங்கு நிறைவு? இங்கே உதவவில்லை. // வகை சரிபார்ப்பு? இல்லை. 'username' சரியான பண்புதானா? // கம்பைலர் இதை அனுமதிக்கிறது, ஆனால் இது இயக்க நேரத்தில் தோல்வியடையக்கூடும். _.find(users, { username: 'fred' });

இந்த நிலையில், _ மாறி any வகையைச் சார்ந்தது. இது டைப்ஸ்கிரிப்ட்டுக்கு, "இந்த மாறியுடன் தொடர்புடைய எதையும் சரிபார்க்க வேண்டாம்" என்று பயனுள்ள வகையில் சொல்கிறது. அனைத்து நன்மைகளையும் நீங்கள் இழக்கிறீர்கள்: தானியங்கு நிறைவு இல்லை, அளவுருக்களில் வகை சரிபார்ப்பு இல்லை, மற்றும் திரும்பும் வகை பற்றி எந்த உறுதியும் இல்லை. இது இயக்க நேரப் பிழைகளுக்கான ஒரு இனப்பெருக்க களம்.

வகை வரையறைகளுடன் கூடிய உலகம்

இப்போது, தேவையான அறிவிப்பு கோப்பை வழங்கும்போது என்ன நடக்கிறது என்பதைப் பார்ப்போம். வகைகளை நிறுவிய பிறகு (அதை அடுத்து காண்போம்), அனுபவம் மாற்றப்பட்டுள்ளது:

import _ from 'lodash'; interface User { user: string; active?: boolean; } const users: User[] = [{ 'user': 'barney' }, { 'user': 'fred' }]; // 1. எடிட்டர் 'find' மற்றும் பிற lodash செயல்பாடுகளுக்கு தானியங்கு நிறைவை வழங்குகிறது. // 2. 'find' மீது ஹோவர் செய்வது அதன் முழு கையொப்பத்தையும் ஆவணங்களையும் காட்டுகிறது. // 3. டைப்ஸ்கிரிப்ட் 'users' என்பது 'User' பொருட்களின் வரிசை என்பதைக் காண்கிறது. // 4. 'User[]' இல் 'find' க்கான predicate, 'user' அல்லது 'active' ஐ உள்ளடக்கும் என்பதை டைப்ஸ்கிரிப்ட் அறியும். // சரி: டைப்ஸ்கிரிப்ட் மகிழ்ச்சியாக உள்ளது. const fred = _.find(users, { user: 'fred' }); // பிழை: டைப்ஸ்கிரிப்ட் தவறை கண்டறிகிறது! // 'User' வகைகளில் 'username' பண்பு இல்லை. const betty = _.find(users, { username: 'betty' });

வேறுபாடு இரவும் பகலும் போன்றது. நாங்கள் முழு வகை பாதுகாப்பு, கருவிகள் மூலம் மேம்பட்ட டெவலப்பர் அனுபவம் மற்றும் சாத்தியமான பிழைகளில் வியத்தகு குறைப்பு ஆகியவற்றைப் பெறுகிறோம். டைப்ஸ்கிரிப்ட் உடன் வேலை செய்வதற்கான தொழில்முறை தரமாகும்.

வகை வரையறைகளைக் கண்டறியும் படிநிலை

எனவே, உங்களுக்குப் பிடித்த நூலகங்களுக்கான இந்த மந்திர .d.ts கோப்புகளை நீங்கள் எவ்வாறு பெறுவீர்கள்? பெரும்பாலான சூழ்நிலைகளை உள்ளடக்கும் ஒரு நன்கு நிறுவப்பட்ட செயல்முறை உள்ளது.

படி 1: நூலகம் அதன் சொந்த வகைகளை தொகுக்கிறதா என சரிபார்க்கவும்

சிறந்த காட்சி என்னவென்றால், ஒரு நூலகம் டைப்ஸ்கிரிப்டில் எழுதப்பட்டிருக்கும்போது அல்லது அதன் பராமரிப்பாளர்கள் அதே தொகுப்பில் அதிகாரப்பூர்வ அறிவிப்பு கோப்புகளை வழங்கும் போது. நன்கு பராமரிக்கப்பட்ட, நவீன திட்டங்களுக்கு இது மிகவும் பொதுவானதாகி வருகிறது.

சரிபார்க்கும் முறை:

1. நூலகத்தை வழக்கம்போல் நிறுவவும்: npm install axios
2. node_modules/axios இல் உள்ள நூலகத்தின் கோப்பை பாருங்கள். ஏதேனும் .d.ts கோப்புகளை நீங்கள் காண்கிறீர்களா?
3. நூலகத்தின் package.json கோப்பில் "types" அல்லது "typings" புலத்தை சரிபார்க்கவும். இந்த புலம் பிரதான அறிவிப்பு கோப்பை நேரடியாக சுட்டிக்காட்டுகிறது. உதாரணமாக, Axios இன் package.json கொண்டுள்ளது: "types": "index.d.ts".

இந்த நிபந்தனைகள் பூர்த்தி செய்யப்பட்டால், நீங்கள் முடித்துவிட்டீர்கள்! டைப்ஸ்கிரிப்ட் இந்த தொகுக்கப்பட்ட வகைகளை தானாகவே கண்டறிந்து பயன்படுத்தும். மேலதிக நடவடிக்கை தேவையில்லை.

படி 2: DefinitelyTyped திட்டம் (@types)

அதன் சொந்த வகைகளை தொகுக்காத ஆயிரக்கணக்கான ஜாவாஸ்கிரிப்ட் நூலகங்களுக்கு, உலகளாவிய டைப்ஸ்கிரிப்ட் சமூகம் ஒரு அற்புதமான வளத்தை உருவாக்கியுள்ளது: DefinitelyTyped.

DefinitelyTyped என்பது GitHub இல் உள்ள ஒரு மையப்படுத்தப்பட்ட, சமூகத்தால் நிர்வகிக்கப்படும் களஞ்சியமாகும், இது ஏராளமான ஜாவாஸ்கிரிப்ட் தொகுப்புகளுக்கான உயர்தர அறிவிப்பு கோப்புகளை கொண்டுள்ளது. இந்த வரையறைகள் @types ஸ்கோப்பின் கீழ் npm பதிவேட்டில் வெளியிடப்படுகின்றன.

பயன்படுத்தும் முறை:

lodash போன்ற ஒரு நூலகம் அதன் சொந்த வகைகளை தொகுக்கவில்லை என்றால், நீங்கள் அதன் தொடர்புடைய @types தொகுப்பை ஒரு மேம்பாட்டு சார்பாக நிறுவ வேண்டும்:

npm install --save-dev @types/lodash

பெயரிடும் மரபு எளிமையானது மற்றும் கணிக்கக்கூடியது: package-name என்ற பெயரிடப்பட்ட நூலகத்திற்கு, அதன் வகைகள் கிட்டத்தட்ட எப்போதும் @types/package-name இல் இருக்கும். நீங்கள் npm இணையதளத்தில் அல்லது நேரடியாக DefinitelyTyped களஞ்சியத்தில் கிடைக்கும் வகைகளைத் தேடலாம்.

ஏன் --save-dev? அறிவிப்பு கோப்புகள் மேம்பாடு மற்றும் தொகுப்பின் போது மட்டுமே தேவைப்படுகின்றன. அவற்றில் எந்த இயக்க நேர குறியீடும் இல்லை, எனவே அவை உங்கள் இறுதி உற்பத்தி தொகுப்பில் சேர்க்கப்படக்கூடாது. அவற்றை devDependency ஆக நிறுவுவது இந்த பிரிவை உறுதி செய்கிறது.

படி 3: வகைகள் இல்லை என்றால் - உங்கள் சொந்ததை எழுதுங்கள்

நீங்கள் ஒரு பழைய, சிறப்பு வாய்ந்த அல்லது உள் தனியார் நூலகத்தைப் பயன்படுத்தினால், அது வகைகளை தொகுக்காது மற்றும் DefinitelyTyped இல் இல்லை என்றால் என்ன செய்வது? இந்த நிலையில், நீங்கள் உங்கள் கைகளை உயர்த்தி உங்கள் சொந்த அறிவிப்பு கோப்பை உருவாக்க வேண்டும். இது அச்சுறுத்தலாகத் தோன்றினாலும், நீங்கள் எளிமையாகத் தொடங்கலாம் மற்றும் தேவைக்கேற்ப மேலும் விவரங்களைச் சேர்க்கலாம்.

விரைவான தீர்வு: சுருக்கமான சுற்றுப்புற தொகுப்பு அறிவிப்பு

சில நேரங்களில், ஒரு முறையான வகை உத்தியை நீங்கள் கண்டறியும் போது, உங்கள் திட்டத்தை பிழையின்றி தொகுக்க வைக்க வேண்டும். உங்கள் திட்டத்தில் ஒரு கோப்பை (எ.கா., declarations.d.ts அல்லது types/global.d.ts) உருவாக்கி ஒரு சுருக்கமான அறிவிப்பைச் சேர்க்கலாம்:

// ஒரு .d.ts கோப்பில் declare module 'some-untyped-library';

இது டைப்ஸ்கிரிப்ட்டுக்கு, "'some-untyped-library' என்ற பெயரிடப்பட்ட ஒரு தொகுப்பு உள்ளது என்று என்னிடம் நம்புங்கள். அதிலிருந்து இறக்குமதி செய்யப்படும் அனைத்தையும் any வகையாகக் கருதுங்கள்." இது கம்பைலர் பிழையை அமைதியாக்குகிறது, ஆனால் நாம் விவாதித்தபடி, அந்த நூலகத்திற்கான அனைத்து வகை பாதுகாப்பையும் தியாகம் செய்கிறது. இது ஒரு தற்காலிக இணைப்பு, நீண்டகால தீர்வு அல்ல.

ஒரு அடிப்படை தனிப்பயன் அறிவிப்பு கோப்பை உருவாக்குதல்

நீங்கள் உண்மையில் பயன்படுத்தும் நூலகத்தின் பகுதிகளுக்கு வகைகளை வரையறுக்கத் தொடங்குவது ஒரு சிறந்த அணுகுமுறை. string-utils என்ற ஒரு எளிய நூலகம் ஒரே ஒரு செயல்பாட்டை ஏற்றுமதி செய்வதாக வைத்துக் கொள்வோம்.

// node_modules/string-utils/index.js இல் module.exports.capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);

உங்கள் திட்டத்தின் ரூட்டில் உள்ள ஒரு பிரத்யேக `types` கோப்புறையில் string-utils.d.ts கோப்பை நீங்கள் உருவாக்கலாம்.

// my-project/types/string-utils.d.ts இல் declare module 'string-utils' { export function capitalize(str: string): string; // நீங்கள் பயன்படுத்தும் மற்ற செயல்பாட்டு வரையறைகளை இங்கு சேர்க்கலாம் // export function slugify(str: string): string; }

இப்போது, எங்கள் தனிப்பயன் வகை வரையறைகளை எங்கு கண்டுபிடிப்பது என்பதை டைப்ஸ்கிரிப்ட்க்கு சொல்ல வேண்டும். இதை tsconfig.json இல் செய்கிறோம்:

{ "compilerOptions": { // ... மற்ற விருப்பங்கள் "baseUrl": ".", "paths": { "*": ["types/*"] } } }

இந்த அமைப்பில், நீங்கள் import { capitalize } from 'string-utils' ஐ இறக்குமதி செய்யும்போது, டைப்ஸ்கிரிப்ட் உங்கள் தனிப்பயன் அறிவிப்பு கோப்பைக் கண்டறிந்து நீங்கள் வரையறுத்த வகை பாதுகாப்பை வழங்கும். நூலகத்தின் அதிக அம்சங்களைப் பயன்படுத்தும்போது நீங்கள் படிப்படியாக இந்த கோப்பை உருவாக்கலாம்.

ஆழமாக டைவிங்: அறிவிப்பு கோப்புகளை எழுதுதல்

அறிவிப்பு கோப்புகளை எழுதும்போதோ அல்லது படிக்கும்போதோ நீங்கள் சந்திக்கும் சில மேம்பட்ட கருத்துக்களை ஆராய்வோம்.

வெவ்வேறு வகையான ஏற்றுமதிகளை அறிவித்தல்

ஜாவாஸ்கிரிப்ட் தொகுப்புகள் பல்வேறு வழிகளில் விஷயங்களை ஏற்றுமதி செய்ய முடியும். உங்கள் அறிவிப்பு கோப்பு நூலகத்தின் ஏற்றுமதி அமைப்பைப் பொருத்த வேண்டும்.

• பெயரிடப்பட்ட ஏற்றுமதிகள்: இது மிகவும் பொதுவானது. அதை மேலே export function capitalize(...) உடன் பார்த்தோம். நீங்கள் மாறிலிகள், இடைமுகங்கள் மற்றும் வகுப்புகளையும் ஏற்றுமதி செய்யலாம்.

declare module 'my-lib' { export const version: string; export interface Options { retries: number; } export function doSomething(options: Options): Promise; }

• இயல்புநிலை ஏற்றுமதி: export default ஐப் பயன்படுத்தும் நூலகங்களுக்கு.

declare module 'my-default-lib' { // ஒரு செயல்பாட்டு இயல்புநிலை ஏற்றுமதிக்கு export default function myCoolFunction(): void; // ஒரு பொருள் இயல்புநிலை ஏற்றுமதிக்கு // const myLib = { name: 'lib', version: '1.0' }; // export default myLib; }

• UMD globals: <script> tag மூலம் உலாவிகளில் வேலை செய்ய வடிவமைக்கப்பட்ட பழைய நூலகங்களுக்கு, அவை பெரும்பாலும் உலகளாவிய `window` பொருளில் தங்களை இணைக்கின்றன. இந்த உலகளாவிய மாறிகளை நீங்கள் அறிவிக்கலாம்.

// ஒரு குறிப்பிட்ட வகையின் உலகளாவிய மாறி '$' ஐ அறிவிக்கிறது declare var $: JQueryStatic;

• `export =` மற்றும் `import = require()`: இந்த தொடரியல் module.exports = ... ஐப் பயன்படுத்தும் பழைய CommonJS தொகுப்புகளுக்கானது. உதாரணமாக, ஒரு நூலகம் module.exports = myClass; ஐ செய்தால்.

  // my-class.d.ts இல் declare class MyClass { constructor(name: string); } export = MyClass; // உங்கள் app.ts இல் import MyClass = require('my-class'); const instance = new MyClass('test');

  நவீன ES தொகுப்புகளுடன் இது குறைவாகப் பொதுவானதாக இருந்தாலும், இது பல பழைய ஆனால் இன்னும் பரவலாகப் பயன்படுத்தப்படும் Node.js தொகுப்புகளுடன் இணக்கத்தன்மைக்கு முக்கியமானது.

தொகுப்பு பெருக்கம்: தற்போதுள்ள வகைகளை நீட்டித்தல்

மிகவும் சக்திவாய்ந்த அம்சங்களில் ஒன்று தொகுப்பு பெருக்கம் (அறிவிப்பு இணைப்பு என்றும் அழைக்கப்படுகிறது). இது மற்றொரு தொகுப்பின் அறிவிப்பு கோப்பில் வரையறுக்கப்பட்ட தற்போதைய இடைமுகங்களுக்கு பண்புகளைச் சேர்க்க உங்களை அனுமதிக்கிறது. Express அல்லது Fastify போன்ற ஒரு plugin கட்டமைப்பைக் கொண்ட நூலகங்களுக்கு இது மிகவும் பயனுள்ளதாக இருக்கும்.

Express இன் `Request` பொருளில் ஒரு `user` பண்பைச் சேர்க்கும் ஒரு middleware ஐ நீங்கள் பயன்படுத்துவதாக கற்பனை செய்து பாருங்கள். பெருக்கம் இல்லாமல், டைப்ஸ்கிரிப்ட் `user` `Request` இல் இல்லை என்று புகார் செய்யும்.

இந்த புதிய பண்பு பற்றி டைப்ஸ்கிரிப்ட்க்கு நீங்கள் எவ்வாறு சொல்லலாம்:

// உங்கள் types/express.d.ts கோப்பில் // அதை பெருக்க, அசல் வகையை இறக்குமதி செய்ய வேண்டும் import { UserProfile } from './auth'; // நீங்கள் ஒரு UserProfile வகையை வைத்திருப்பதாகக் கருதுகிறது // 'express-serve-static-core' தொகுப்பை நாங்கள் பெருக்கிக் கொண்டிருக்கிறோம் என்று டைப்ஸ்கிரிப்ட்க்கு சொல்லுங்கள் declare module 'express-serve-static-core' { // அந்த தொகுப்பிற்குள் 'Request' இடைமுகத்தை குறிவைக்கவும் interface Request { // எங்கள் தனிப்பயன் பண்பைச் சேர்க்கவும் user?: UserProfile; } }

இப்போது, உங்கள் பயன்பாடு முழுவதும், Express `Request` பொருள் விருப்பமான `user` பண்புடன் சரியாக வகைப்படுத்தப்படும், மேலும் நீங்கள் முழு வகை பாதுகாப்பு மற்றும் தானியங்கு நிறைவைப் பெறுவீர்கள்.

மூன்று-ஸ்லாஷ் directives

நீங்கள் சில சமயங்களில் .d.ts கோப்புகளின் மேல் மூன்று ஸ்லாஷ்களுடன் (///) தொடங்கும் கருத்துக்களைக் காணலாம். இவை கம்பைலர் அறிவுறுத்தல்களாக செயல்படும் மூன்று-ஸ்லாஷ் directives ஆகும்.

• /// <reference types="..." />: இது மிகவும் பொதுவானது. இது மற்றொரு தொகுப்பின் வகை வரையறைகளை ஒரு சார்பாக வெளிப்படையாக உள்ளடக்குகிறது. உதாரணமாக, WebdriverIO plugin க்கான வகைகள் /// <reference types="webdriverio" /> ஐ உள்ளடக்கியிருக்கலாம், ஏனெனில் அதன் சொந்த வகைகள் முக்கிய WebdriverIO வகைகளைச் சார்ந்துள்ளது.
• /// <reference path="..." />: இது அதே திட்டத்திற்குள் மற்றொரு கோப்பில் ஒரு சார்பை அறிவிக்கப் பயன்படுகிறது. இது ஒரு பழைய தொடரியல், ES தொகுப்பு இறக்குமதிகளால் பெருமளவில் மாற்றப்பட்டுள்ளது.

அறிவிப்பு கோப்புகளை நிர்வகிப்பதற்கான சிறந்த நடைமுறைகள்

1. தொகுக்கப்பட்ட வகைகளுக்கு முன்னுரிமை கொடுங்கள்: நூலகங்களுக்கு இடையில் தேர்வு செய்யும்போது, டைப்ஸ்கிரிப்டில் எழுதப்பட்ட அல்லது அவற்றின் சொந்த அதிகாரப்பூர்வ வகை வரையறைகளை தொகுக்கும் நூலகங்களுக்கு முன்னுரிமை கொடுங்கள். இது டைப்ஸ்கிரிப்ட் சூழலுக்கான அர்ப்பணிப்பைக் குறிக்கிறது.
2. @types ஐ devDependencies இல் வைத்திருங்கள்: எப்போதும் @types தொகுப்புகளை --save-dev அல்லது -D உடன் நிறுவவும். அவை உங்கள் உற்பத்தி குறியீட்டிற்கு தேவையில்லை.
3. பதிப்புகளை சீரமைக்கவும்: பிழைகளின் ஒரு பொதுவான ஆதாரம் நூலகப் பதிப்பு மற்றும் அதன் @types பதிப்பிற்கு இடையே உள்ள பொருந்தாமை. ஒரு நூலகத்தில் ஒரு பெரிய பதிப்பு அதிகரிப்பு (எ.கா., v2 இலிருந்து v3) அதன் API இல் உடைக்கும் மாற்றங்களைக் கொண்டிருக்கலாம், இது @types தொகுப்பில் பிரதிபலிக்கப்பட வேண்டும். அவற்றை சீரமைக்க முயற்சிக்கவும்.
4. கட்டுப்பாட்டிற்கு tsconfig.json ஐப் பயன்படுத்தவும்: உங்கள் tsconfig.json இல் உள்ள typeRoots மற்றும் types கம்பைலர் விருப்பங்கள், டைப்ஸ்கிரிப்ட் அறிவிப்பு கோப்புகளை எங்கு தேட வேண்டும் என்பதற்கு உங்களுக்கு நுணுக்கமான கட்டுப்பாட்டை வழங்க முடியும். typeRoots எந்த கோப்புறைகளை சரிபார்க்க வேண்டும் என்பதை கம்பைலருக்கு சொல்கிறது (இயல்பாக, இது ./node_modules/@types), மற்றும் types சேர்க்க வேண்டிய வகை தொகுப்புகளை வெளிப்படையாக பட்டியலிட உங்களை அனுமதிக்கிறது.
5. திரும்பி பங்களிக்கவும்: நீங்கள் ஒரு விரிவான அறிவிப்பு கோப்பை எழுதினால், அதை ஒரு நூலகத்திற்கு எழுதும் போது, அதை DefinitelyTyped திட்டத்திற்கு பங்களிப்பதைக் கவனியுங்கள். இது உலகளாவிய டெவலப்பர் சமூகத்திற்கு திரும்பக் கொடுப்பதற்கும் ஆயிரக்கணக்கான மற்றவர்களுக்கு உதவுவதற்கும் ஒரு அற்புதமான வழியாகும்.

முடிவுரை: வகை பாதுகாப்பின் பாடகப்படாத நாயகர்கள்

டைப்ஸ்கிரிப்ட் அறிவிப்பு கோப்புகள், டைனமிக், பரந்து விரிந்த ஜாவாஸ்கிரிப்ட் உலகத்தை ஒரு வலுவான, வகை-பாதுகாப்பான மேம்பாட்டு சூழலில் தடையின்றி ஒருங்கிணைக்க சாத்தியமாக்கும் பாடகப்படாத நாயகர்கள். அவை எங்கள் கருவிகளை சக்திவாய்ப்படுத்தும், எண்ணற்ற பிழைகளைத் தடுக்கும் மற்றும் எங்கள் குறியீட்டு தளங்களை மேலும் மீள்தன்மையுடனும் சுய-ஆவணப்படுத்துதலுடனும் மாற்றும் முக்கியமான இணைப்பு.

உங்கள் சொந்த .d.ts கோப்புகளை எவ்வாறு கண்டுபிடிப்பது, பயன்படுத்துவது மற்றும் உருவாக்குவது என்பதைப் புரிந்துகொள்வதன் மூலம், நீங்கள் ஒரு கம்பைலர் பிழையை சரிசெய்வதை விட அதிகமாகச் செய்கிறீர்கள் - நீங்கள் உங்கள் முழு மேம்பாட்டுப் பணிப்பாய்வுகளையும் உயர்த்துகிறீர்கள். நீங்கள் டைப்ஸ்கிரிப்ட் மற்றும் ஜாவாஸ்கிரிப்ட் நூலகங்களின் வளமான சூழல் இரண்டின் முழு திறனையும் திறக்கிறீர்கள், இது சிறந்த, மேலும் நம்பகமான மென்பொருளை உலகளாவிய பார்வையாளர்களுக்காக உருவாக்குகிறது.